home *** CD-ROM | disk | FTP | other *** search
/ Programmer Power Tools / Programmer Power Tools.iso / dskutl / dsktst.arc / DSKTST.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-08-06  |  5.8 KB  |  202 lines
  1. #include <stdio.h>
  2. #include <dos.h>
  3. #include <malloc.h>
  4. extern char *dskerrmsg();
  5. union xxx {
  6.   char secbuffer [512];
  7.  
  8.   struct hdr {
  9.     char spare [11];
  10.     int  sectorsize;
  11.     char clustersize;
  12.     int  reserved_sectors;
  13.     char number_of_fats;
  14.     int  root_entries;
  15.     unsigned  total_sectors;
  16.     char media_type;
  17.     int  fat_size;
  18.     int  track_size;
  19.     int  head_count;
  20.     unsigned  hidden_sectors;
  21.     } dh;
  22.  
  23.   struct ptab {
  24.     char spare[446];
  25.     char boot_ind;
  26.     char br_head;
  27.     char br_sect;
  28.     char br_cyl;
  29.     } pt;
  30.  
  31. };
  32.  
  33. union xxx db;
  34.  
  35.  
  36.  
  37.  
  38. main(argc, argv)
  39. int argc;
  40. char **argv;
  41.  
  42.  
  43. {
  44. char diskdrive[128];
  45. int total_errors = 0;           /* total bad sectors */
  46. int drive = 0;
  47. int head = 0;
  48. int cyl = 0;
  49. int rec = 0;
  50. int err, i, cyl_count;
  51. char *trakbuf;               /* buffer for the track - allocated later */
  52. int row = 0;
  53. int col = 0;               /* current cursor position */
  54. char media = 0;
  55.  
  56. /******************************************************************************
  57. *                                          *
  58. *  read the input parameter string to determine drive                  *
  59. *                                          *
  60. ******************************************************************************/
  61. printf("Diskette/Fixed disk verifier program\n");
  62. printf("Non-Copyrighted -- by Bob Murphy\n");
  63.  
  64. diskdrive[0] = '\0';               /* null the string */
  65. if (argc > 1)
  66.   {
  67.   char **p;
  68.   p=argv;               /* p points to first argument pointer */
  69.   p++;                   /* point to drive id */
  70.   strcpy(diskdrive,*p);        /* copy the drive id */
  71.   i = strlen(diskdrive);       /* get the length */
  72.   while(i >= 0)
  73.     {                   /* convert to upper case */
  74.     if (diskdrive[i] >= 'a' && diskdrive[i] <= 'z')
  75.     diskdrive[i] = (diskdrive[i] - 32);
  76.     i--;
  77.     }
  78.   }
  79. if (diskdrive[0] >= 'A' && diskdrive[0] <= 'D' && diskdrive[1] == ':')
  80.   drive = diskdrive[0] - 'A';
  81. else
  82.   { drive = defdrv();
  83.     strcpy(diskdrive,"A:");
  84.     diskdrive[0] = 'A' + drive;
  85.   }
  86. media = getfatid(drive+1);       /* find out if its a hard disk */
  87. if (media == (char) 0xf8)  drive = (drive - 2) | 0x80; /* if yes - set hard */
  88.  
  89.  
  90.  
  91. locate(row,col);
  92. clrcrt(7);             /* erase & home, color = w on bk */
  93. printf("Drive %s\n",diskdrive);
  94.  
  95. /******************************************************************************
  96. *                                          *
  97. *  read in the first record from the disk                      *
  98. *                                          *
  99. ******************************************************************************/
  100. i=3;                   /* allow 3 retries */
  101. while (i)
  102. {
  103.   err = absread(drive,0,0,1,1,&db);    /* read sector 1, first track */
  104.   if (! err) break;
  105.   i--;
  106. }
  107.  
  108.  
  109. if ((! err) && (drive == 0x80))
  110.   {
  111.   char *ptptr;               /* partition table pointer */
  112.   ptptr = &db.pt.boot_ind;       /* point to boot indicator */
  113.   i = 4; err=0xffff;
  114.   while (i)
  115.     {
  116.     if (*ptptr == (char) 0x80)
  117.       {
  118.       head = *(++ptptr);         /* read starting head from part table */
  119.       i = *(++ptptr);          /* read starting sec from part table */
  120.       cyl  = *(++ptptr);         /* read starting cyl from part table */
  121.       rec = (i & 0x3f);          /* strip out cylinder bits */
  122.       cyl = ((i & 0xc0) << 2) + cyl; /* set up the cylinder */
  123.       err = 0;
  124.       break;
  125.       }
  126.     i--; ptptr = ptptr + 16;
  127.  
  128.     }                   /* end while */
  129.     if (! err) err = absread(drive,cyl,head,rec,1,&db); /* read dos boot rec */
  130.   }                   /* endif */
  131. if (db.dh.track_size == 0 && err == 0) err = 0xff; /*err ff = wierd disk */
  132. /*
  133.  
  134.  
  135.  
  136. */
  137. if (! err)
  138.   {
  139.   char mdb[5];               /* scratchpad for media descriptor */
  140.   sprintf(&mdb[0],"%x",media);
  141.   printf("%u Reserved Sector(s)\n",db.dh.reserved_sectors);
  142.   printf("%u Bytes / sector\n",db.dh.sectorsize);
  143.   printf("%u Allocation Tables\n",db.dh.number_of_fats);
  144.   printf("%u Root Directory Entries\n",db.dh.root_entries);
  145.   printf("%u Total DOS Sectors\n",db.dh.total_sectors);
  146.   printf("%u Sectors in a FAT\n",db.dh.fat_size);
  147.   printf("%u Sectors / Track\n",db.dh.track_size);
  148.   printf("%u Surfaces\n",db.dh.head_count);
  149.   printf("%u Hidden Sectors\n",db.dh.hidden_sectors);
  150.   printf("%s Media Descriptor\n",&mdb [2]);
  151.   }
  152. else
  153.   printf("%s Error reading boot sector -- program aborting\n",dskerrmsg(err));
  154.  
  155.  
  156. /******************************************************************************
  157. *                                          *
  158. *  allocate track buffer, and read tracks looking for errors              *
  159. *                                          *
  160. ******************************************************************************/
  161.  
  162. if (! err)
  163.   {
  164.   i = db.dh.track_size * db.dh.sectorsize; /* buffer size for 1 track */
  165.   trakbuf = malloc(i);               /* allocate buffer */
  166.   cyl_count = (db.dh.total_sectors / db.dh.track_size /db.dh.head_count);
  167.  
  168.   while (cyl < cyl_count)
  169.     {
  170.     csrpos(&row,&col);           /* get current cursor */
  171.     printf("cyl=%d",cyl);
  172.     locate(row,col);
  173.     err = absread(drive,cyl,head++,1,db.dh.track_size,trakbuf);
  174.     if (err)
  175.       {
  176.       head--;               /* reset head back to correct surface */
  177.       i = 1;               /* current sector number */
  178.       while (i <= db.dh.track_size)
  179.     {
  180.     err = absread(drive,cyl,head,i,1,trakbuf);  /* READ 1 SECTOR */
  181.     if (err)
  182.       {
  183.       char *mptr;
  184.       mptr = dskerrmsg(err);
  185.       printf("%s Error -- Cyl %d Head %d Record %d\n",mptr,cyl,head,i);
  186.       total_errors++;
  187.       }
  188.  
  189.     i++;               /* bump current sector */
  190.     }
  191.       head++;               /* set head to next surface */
  192.       }                /* end of if (err) */
  193.     if (head >= db.dh.head_count) { head = 0; cyl++; }
  194.     }                   /* end of while (cyl <= cyl_count) */
  195.  
  196.   if (total_errors) printf("          \n%d Total Bad Sectors\n",total_errors);
  197.   else printf("          \nDiskette is error free\n");
  198.  
  199.   }                   /* end of if (! err) */
  200.  
  201. }                   /* end of main */
  202.